home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / self / contrib.lha / contrib / SelfNews / wireI.C < prev    next >
C/C++ Source or Header  |  1993-07-24  |  12KB  |  518 lines
  1. /* File wireI.C
  2.  * created by Ian Wilkinson on Thu Sep 10 16:15:30 1992
  3.  *
  4.  * Copyright (c) Canon Research Centre Europe, 1992.
  5.  * All rights reserved.
  6.  */
  7.  
  8. #include <_glueDefs.c.incl>
  9. #include <NeWS/psio.h>
  10. #include <wire/wire.h>
  11. #include <jot/jot.h>
  12. #include "wireIPS.h"
  13.  
  14. // From unixPrims.h.
  15. extern fd_set activeFDs;                      // active file descriptors
  16.  
  17. char *WireSeal     = "wire_Wire";
  18. char *JotViewSeal  = "JotView";
  19. char *JotTextSeal  = "JotText";
  20. char *JotRulerSeal = "JotRuler";
  21.  
  22. #define toCntl( c )    (c & 037)
  23.  
  24. void
  25. kybdManager( JotView *jotView, char ch )
  26. {
  27.     if (JotView_ReadOnly(jotView) == FALSE) {
  28.     JotText *jotText;
  29.     int caretPosn;
  30.     jotText = JotView_Text(jotView);
  31.     caretPosn = JotText_Caret(jotText);
  32.  
  33.     switch (ch) {
  34.         case toCntl('D'):
  35.         case '\177':
  36.         (void)JotText_DeleteCharacters(jotText, caretPosn, (ch == toCntl('D')) ?
  37.             1 : -1);
  38.         break;
  39.  
  40.         case '\r':
  41.         ch = '\n';
  42.         default:
  43.         JotText_InsertCharacters(jotText, caretPosn, &ch, 1);
  44.         break;
  45.     }
  46.     JotView_EnsurePositionVisible(jotView, JotText_Caret(jotText));
  47.     }
  48. }
  49.  
  50. int
  51. jotInitialize( int w )
  52. {
  53.     Jot_Initialize((wire_Wire)w);
  54.     return 1;
  55. }
  56.  
  57. JotText *
  58. newJotText( int initialSz )
  59. {
  60.     return JotText_New(initialSz);
  61. }
  62.  
  63. int
  64. placeAtEnd( char *text, JotText *jotText, void *FH )
  65. {
  66.     int nChars;
  67.     JotView *jotView;
  68.     nChars = JotText_Characters(jotText);
  69.     if (JotText_InsertString(jotText, nChars, text) == -1) {
  70.     failure(FH, "JotText_InsertString");
  71.     return 0;
  72.     }
  73.     if ((jotView = JotText_FirstView(jotText)) == 0) {
  74.     failure(FH, "JotText_FirstView");
  75.     return 0;
  76.     }
  77.     JotView_Update(jotView);
  78.     return 1;
  79. }
  80.  
  81. JotView *
  82. newJotView( JotText *jotText, int isCanvasReqd, int w, void *FH )
  83. {
  84.     JotView *jotView;
  85.     wire_SetCurrent(w);
  86.     jotView = JotView_New(jotText, (boolean)isCanvasReqd);
  87.     JotView_SetEventHandlers(jotView, Jot_KEYBOARD_EVENT, kybdManager, Jot_NULL_EVENT);
  88.     if (ps_flush_PostScript() == -1) {
  89.     failure(FH, "ps_flush_PostScript in newJotView");
  90.     return 0;
  91.     }
  92.     return jotView;
  93. }
  94.  
  95. int
  96. jotViewCanvas( JotView *jotView )
  97. {
  98.     return JotView_Canvas(jotView);
  99. }
  100.  
  101. int
  102. jotViewSetReadOnly( int isProtected, JotView *jotView )
  103. {
  104.     JotView_SetReadOnly(jotView, (boolean)isProtected);
  105.     return 1;
  106. }
  107.  
  108. int
  109. jotViewAspects( JotView *jotView )
  110. {
  111.     int tk;
  112.     wire_Wire w;
  113.     tk = JotView_Canvas(jotView);
  114.     w = JotView_Wire(jotView);
  115.     wire_SetCurrent(w);
  116.     PSjotViewAspects(tk);
  117.     return wire_ReadInt();
  118. }
  119.  
  120. int
  121. jotViewBehaviour( JotView *jotView, int *behaviour )
  122. {
  123.     int tk;
  124.     wire_Wire w;
  125.     int aspects;
  126.     tk = JotView_Canvas(jotView);
  127.     w = JotView_Wire(jotView);
  128.     wire_SetCurrent(w);
  129.     PSjotViewBehaviour(tk);
  130.     aspects = wire_ReadInt();
  131.     for (int i = 0; i < aspects; i++)
  132.     behaviour[i] = wire_ReadInt();
  133.     return 1;
  134. }
  135.  
  136. int
  137. jotViewRespond( JotView *jotView, void *FH )
  138. {
  139.     wire_Wire jotViewW;
  140.  
  141.     jotViewW = JotView_Wire(jotView);
  142.     wire_SetCurrent(jotViewW);
  143.     while (ps_check_input()) {
  144.     wire_Handler callback;
  145.     int tg;
  146.  
  147.     if (ps_peek_tag(&tg) == 1) {
  148.         tg = wire_ReadTag();
  149.         callback = wire_TagProc(tg);
  150.         callback(tg, 0);
  151.     }
  152.     else {
  153.         break;
  154.     }
  155.     }
  156.     JotView_UpdateViews();
  157.     return 1;
  158. }
  159.  
  160. JotRuler *
  161. newJotRuler()
  162. {
  163.     return JotRuler_New();
  164. }
  165.  
  166. int
  167. jotFontInitialize( JotRuler *ruler, JotView *jotView, JotText *jotText )
  168. {
  169.     JotFont *font;
  170.     wire_Wire w;
  171.     w = JotView_Wire(jotView);
  172.     wire_SetCurrent(w);
  173.     JotView_SetPrinterMatchFonts(jotView, TRUE);
  174.     font = JotFont_New("LucidaSans");
  175.     JotRuler_SetParameters(ruler, Jot_FONT, font,
  176.                   Jot_BOLD, FALSE,
  177.                   Jot_FONT_SIZE, 10,
  178.                   Jot_NULL_PARAMETER);
  179.     JotText_SetDefaultRuler(jotText, ruler);
  180.     return 1;
  181. }
  182.  
  183. int
  184. jotRulerSetParameter( JotRuler *ruler, int parameter, int value )
  185. {
  186.     JotRuler_SetParameters(ruler, parameter, value, Jot_NULL_PARAMETER);
  187.     return 1;
  188. }
  189.  
  190. int
  191. jotRulerSetFont( JotRuler *ruler, char *fontName )
  192. {
  193.     JotFont *font;
  194.     font = JotFont_New(fontName);
  195.     JotRuler_SetParameters(ruler, Jot_FONT, font, Jot_NULL_PARAMETER);
  196.     return 1;
  197. }
  198.  
  199. int
  200. jotRulerSetRulerName( JotRuler *ruler, char *rulerName )
  201. {
  202.     JotRuler_SetParameters(ruler, Jot_RULER_NAME, rulerName, Jot_NULL_PARAMETER);
  203.     return 1;
  204. }
  205.  
  206. int
  207. jotViewUpdate( int w, JotView *jotView )
  208. {
  209.     wire_SetCurrent(w);
  210.     JotView_Update(jotView);
  211.     return 1;
  212. }
  213.  
  214. int
  215. jotTextSize( JotText *jotText )
  216. {
  217.     return JotText_Characters(jotText);
  218. }
  219.  
  220. int
  221. jotTextContentsInto( char *s, JotText *jotText, void *FH )
  222. {
  223.     int jotTextSz;
  224.     JotSpan *jotSpan;
  225.     jotTextSz = JotText_Characters(jotText);
  226.     if ((jotSpan = JotSpan_New(jotText, 0, jotTextSz)) == 0) {
  227.     failure(FH, "...in jotTextContentsInto: JotSpan_New");
  228.     return 0;
  229.     }
  230.     if (JotSpan_Contents(jotSpan, s) == -1) {
  231.     failure(FH, "...in jotTextContentsInto: JotSpan_Contents");
  232.     return 0;
  233.     }
  234.     JotSpan_Free(jotSpan);
  235.     return 1;
  236. }
  237.  
  238. int
  239. wireAllocateTags( int w, int nTgs )
  240. {
  241.     wire_SetCurrent((wire_Wire)w);
  242.     return wire_AllocateTags(nTgs);
  243. }
  244.  
  245. int
  246. wireAllocateTokens( int w, int nTks )
  247. {
  248.     return wire_AllocateTokens((wire_Wire)w, nTks);
  249. }
  250.  
  251. int
  252. wireDeallocateToken( int w, int tk )
  253. {
  254.     return wire_DeallocateTokens((wire_Wire)w, tk, 1);
  255. }
  256.  
  257. int
  258. wireClose( int w, void *FH )
  259. {
  260.     if (wire_Close((wire_Wire)w) == FALSE) {
  261.     failure(FH, wire_ErrorString());
  262.     return 0;
  263.     }
  264.     return 1;
  265. }
  266.  
  267. int
  268. wireCurrent()
  269. {
  270.     return wire_Current();
  271. }
  272.  
  273. int
  274. wireEnable( int w, void *FH )
  275. {
  276.     if (wire_Enable((wire_Wire)w) == FALSE) {
  277.     failure(FH, wire_ErrorString());
  278.     return 0;
  279.     }
  280.     return 1;
  281. }
  282.  
  283. char*
  284. wireErrorString()
  285. {
  286.     return wire_ErrorString();
  287. }
  288.  
  289. int
  290. wireInputFd( int w )
  291. {
  292.    PSFILE *psiop;
  293.    psiop = wire_PSinput(w);
  294.    return psio_fileno(psiop);
  295. }
  296.  
  297. int
  298. wireOutputFd( int w )
  299. {
  300.    PSFILE *psiop;
  301.    psiop = wire_PSoutput(w);
  302.    return psio_fileno(psiop);
  303. }
  304.  
  305. int
  306. wireOpen( char *display, void *FH )
  307. {
  308.     wire_Wire w;
  309.     if ((w = wire_Open(display)) == wire_INVALID_WIRE) {
  310.     failure(FH, wire_ErrorString());
  311.     return 0;
  312.     }
  313.     FD_SET(wireOutputFd(w), &activeFDs);
  314.     return w;
  315. }
  316.  
  317. int
  318. wireReadTag( int w )
  319. {
  320.     wire_SetCurrent((wire_Wire)w);
  321.     return wire_ReadTag();
  322. }
  323.  
  324. int
  325. wireReadInt( int w )
  326. {
  327.     wire_SetCurrent((wire_Wire)w);
  328.     return wire_ReadInt();
  329. }
  330.  
  331. char*
  332. wireReadString( int w, char *aString )
  333. {
  334.     wire_SetCurrent((wire_Wire)w);
  335.     return wire_ReadString(aString);
  336. }
  337.  
  338. int
  339. wireSetCurrent( int w, void *FH )
  340. {
  341.     if (wire_SetCurrent((wire_Wire)w) == FALSE) {
  342.     failure(FH, wire_ErrorString());
  343.     return 0;
  344.     }
  345.     return 1;
  346. }
  347.  
  348. int
  349. wireSkipEvent( int w, void *FH )
  350. {
  351.     wire_SetCurrent((wire_Wire)w);
  352.     if (wire_SkipEvent() == FALSE) {
  353.     failure(FH, wire_ErrorString());
  354.     return 0;
  355.     }
  356.     return 1;
  357. }
  358.  
  359. int
  360. wireValid( int w, void *FH )
  361. {
  362.     if (wire_Valid((wire_Wire)w) == FALSE) {
  363.     failure(FH, wire_ErrorString());
  364.     return 0;
  365.     }
  366.     return 1;
  367. }
  368.  
  369. int
  370. wireWouldNotify( int w )
  371. {
  372.     return wire_WouldNotify((wire_Wire)w);
  373. }
  374.  
  375. int
  376. wireInvalidWire()
  377. {
  378.     return wire_INVALID_WIRE;
  379. }
  380.  
  381. int
  382. psLoadPackages( int w, void *FH )
  383. {
  384.     wire_SetCurrent((wire_Wire)w);
  385.     PSloadPackages();
  386.     if (ps_flush_PostScript() == -1) {
  387.     failure(FH, "Problem with psLoadPackages");
  388.     return 0;
  389.     }
  390.     return 1;
  391. }
  392.  
  393. int
  394. psSend( int w, char *psFragment, void *FH )
  395. {
  396.     wire_SetCurrent((wire_Wire)w);
  397.     PSsend(psFragment);
  398.     if (ps_flush_PostScript() == -1) {
  399.     failure(FH, "Problem with psSend");
  400.     return 0;
  401.     }
  402.     return 1;
  403. }
  404.  
  405. int
  406. psSendTo( int w, int tk, char *psFragment, void *FH )
  407. {
  408.     wire_SetCurrent((wire_Wire)w);
  409.     PSsendTo(tk, psFragment);
  410.     if (ps_flush_PostScript() == -1) {
  411.     failure(FH, "Problem with psSendTo");
  412.     return 0;
  413.     }
  414.     return 1;
  415. }
  416.  
  417. int
  418. psSyncReply( int w, int tk, char *psFragment, void *FH )
  419. {
  420.     wire_SetCurrent((wire_Wire)w);
  421.     PSsyncReply(tk, psFragment);
  422.     if (ps_flush_PostScript() == -1) {
  423.     failure(FH, "Problem with psSyncReply");
  424.     return 0;
  425.     }
  426.     return 1;
  427. }
  428.  
  429. int
  430. psFlushPostScript( int w, void *FH )
  431. {
  432.     wire_SetCurrent((wire_Wire)w);
  433.     if (ps_flush_PostScript() == -1) {
  434.     failure(FH, "Problem with ps_flush_PostScript");
  435.     return 0;
  436.     }
  437.     return 1;
  438. }
  439.  
  440. int
  441. peekTag( int w, void *FH )
  442. {
  443.     int isTg, tg;
  444.     wire_SetCurrent((wire_Wire)w);
  445.     if ((isTg = ps_peek_tag(&tg)) == -1) {
  446.     failure(FH, "Problem with ps_peek_tag");
  447.     return 0;
  448.     }
  449.     return (isTg ? tg : -1);
  450. }
  451.  
  452. int
  453. checkInput( int w, void *FH )
  454. {
  455.     int isEmpty;
  456.     wire_SetCurrent((wire_Wire)w);
  457.     if ((isEmpty = ps_check_input()) == -1) {
  458.     failure(FH, "Problem with ps_check_input");
  459.     return 0;
  460.     }
  461.     return isEmpty;
  462. }
  463.  
  464. #define WHAT_GLUE FUNCTIONS
  465.     C_func_2(int,, wireAllocateTags, allocateTagsGlue,, proxy, (int, WireSeal), int,)
  466.     C_func_2(int,, wireAllocateTokens, allocateTokensGlue,, proxy, (int, WireSeal), int,)
  467.     C_func_2(bool,, wireDeallocateToken, deallocateTokenGlue,, proxy, (int, WireSeal), int,)
  468.     C_func_1(bool,, wireClose, closeGlue, fail, proxy, (int, WireSeal))
  469.     C_func_0(int,, wireCurrent, currentGlue,)
  470.     C_func_1(bool,, wireEnable, enableGlue, fail, proxy, (int, WireSeal))
  471.     C_func_0(string,, wireErrorString, errorStringGlue,)
  472.     C_func_1(proxy, (int, WireSeal), wireOpen, openGlue, fail, string,)
  473.     C_func_1(int,, wireReadTag, readTagGlue,, proxy, (int, WireSeal))
  474.     C_func_1(int,, wireReadInt, readIntGlue,, proxy, (int, WireSeal))
  475.     C_func_2(string,, wireReadString, readStringGlue,, proxy, (int, WireSeal), string,)
  476.     C_func_1(bool,, wireSetCurrent, setCurrentGlue, fail, proxy, (int, WireSeal))
  477.     C_func_1(bool,, wireSkipEvent, skipEventGlue, fail, proxy, (int, WireSeal))
  478.     C_func_1(bool,, wireValid, validGlue, fail, proxy, (int, WireSeal))
  479.     C_func_1(bool,, wireWouldNotify, wouldNotifyGlue,, proxy, (int, WireSeal))
  480.     C_func_0(int,, wireInvalidWire, invalidWireGlue,)
  481.     C_func_1(int,, wireInputFd, wireInputFdGlue,, proxy, (int, WireSeal))
  482.     C_func_1(int,, wireOutputFd, wireOutputFdGlue,, proxy, (int, WireSeal))
  483.     C_func_1(int,, psLoadPackages, loadPackagesGlue, fail, proxy, (int, WireSeal))
  484.     C_func_2(int,, psSend, sendGlue, fail, proxy, (int, WireSeal), string,)
  485.     C_func_3(int,, psSendTo, sendToGlue, fail, proxy, (int, WireSeal), int,, string,)
  486.     C_func_3(int,, psSyncReply, syncReplyGlue, fail, proxy, (int, WireSeal), int,, string,)
  487.     C_func_1(int,, psFlushPostScript, flushPostScriptGlue, fail, proxy, (int, WireSeal))
  488.     C_func_1(int,, peekTag, peekTagGlue, fail, proxy, (int, WireSeal))
  489.     C_func_1(bool,, checkInput, checkInputGlue, fail, proxy, (int, WireSeal))
  490.     C_func_1(bool,, jotInitialize, jotInitializeGlue,, proxy, (int, WireSeal))
  491.     C_func_1(proxy_null, (JotText *, JotTextSeal), newJotText, newJotTextGlue,, int,)
  492.     C_func_3(proxy_null, (JotView *, JotViewSeal), newJotView, newJotViewGlue, fail,
  493.     proxy, (JotText *, JotTextSeal), bool,, proxy, (int, WireSeal))
  494.     C_func_2(bool,, placeAtEnd, placeAtEndGlue, fail, string,, proxy, (JotText *, JotTextSeal))
  495.     C_func_1(int,, jotTextSize, sizeGlue,, proxy, (JotText *, JotTextSeal))
  496.     C_func_2(bool,, jotTextContentsInto, contentsIntoGlue, fail,
  497.     bv, char *, proxy, (JotText *, JotTextSeal))
  498.     C_func_2(bool,, jotViewSetReadOnly, jotViewSetReadOnlyGlue,,
  499.     bool,, proxy, (JotView *, JotViewSeal))
  500.     C_func_1(int,, jotViewCanvas, jotViewCanvasGlue,, proxy, (JotView *, JotViewSeal))
  501.     C_func_1(int,, jotViewAspects, jotViewAspectsGlue,, proxy, (JotView *, JotViewSeal))
  502.     C_func_2(int,, jotViewBehaviour, jotViewBehaviourGlue,,
  503.     proxy, (JotView *, JotViewSeal), bv, int *)
  504.     C_func_1(bool,, jotViewRespond, jotViewRespondGlue, fail, proxy, (JotView *, JotViewSeal))
  505.     C_func_2(bool,, jotViewUpdate, jotViewUpdateGlue,, proxy, (int, WireSeal), proxy, (JotView *, JotViewSeal))
  506.     C_func_0(proxy_null, (JotRuler *, JotRulerSeal), newJotRuler, newJotRulerGlue,)
  507.     C_func_3(bool,, jotFontInitialize, jotFontInitializeGlue,,
  508.     proxy, (JotRuler *, JotRulerSeal),
  509.     proxy, (JotView *, JotViewSeal),
  510.     proxy, (JotText *, JotTextSeal))
  511.     C_func_3(bool,, jotRulerSetParameter, jotRulerSetParameterGlue,,
  512.     proxy, (JotRuler *, JotRulerSeal), int,, int,)
  513.     C_func_2(bool,, jotRulerSetFont, jotRulerSetFontGlue,,
  514.     proxy, (JotRuler *, JotRulerSeal), string,)
  515.     C_func_2(bool,, jotRulerSetRulerName, jotRulerSetRulerNameGlue,,
  516.     proxy, (JotRuler *, JotRulerSeal), string,)
  517. #undef WHAT_GLUE
  518.